package com.tsugun.mediaplayer.view.activity;

import android.Manifest;
import android.app.Fragment;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;

import android.os.Environment;
import android.preference.PreferenceManager;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;

import com.tsugun.mediaplayer.R;
import com.tsugun.mediaplayer.presenter.manager.MusicFragmentManager;
import com.tsugun.mediaplayer.presenter.provider.ListProvider;
import com.tsugun.mediaplayer.presenter.provider.MusicListProvider;
import com.tsugun.mediaplayer.presenter.utils.LogHelper;
import com.tsugun.mediaplayer.presenter.utils.SettingPreferenceHelper;
import com.tsugun.mediaplayer.presenter.utils.SystemHelper;
import com.tsugun.mediaplayer.view.loader.MediaImageLoad;

import java.io.File;

/**
 * Base activity for activities that need to show a playback control fragment when media is playing.
 */
public abstract class BaseActivity extends AppCompatActivity {

    public static String CACHE_DIR;
    protected static final short PERMISSION_EXTERNAL_STORAGE = 0x10;
    private static boolean isGranted = false;

    private static ListProvider mMusicListProvider;
    // 是否加载完毕
    private static boolean isLoad = false;
    private MusicFragmentManager mFragmentManager;
    // 设置参数
    private SharedPreferences mSharedPreferences;

    /**
     * 加载音乐列表
     */
    private void loadMusic() {
        mMusicListProvider = new MusicListProvider(this);
        mMusicListProvider.retrieveMediaAsync(new MusicListProvider.ProviderCallback() {
            @Override
            public void onMusicCatalogReady(boolean isInit) {
                isLoad = true;
                if (isInit) {
                    onMusicLoadComplete(mMusicListProvider);
                } else {
                    onMusicLoadFailed();
                }
            }
        });
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        init();
    }

    /**
     * 如果启动时使用的全屏启动界面将无法关闭引用
     */
    private void init() {
        // 设置目标图片缓存最大尺寸
        if (!isLoad) {
            MediaImageLoad.setCacheSize(SystemHelper.INSTANCE.getScreensWidth(this) / 2);
        }
        mFragmentManager = new MusicFragmentManager(this);
        mFragmentManager.setContainerViewId(R.id.id_index_fragment);
        mSharedPreferences = PreferenceManager.getDefaultSharedPreferences(this);
        mSharedPreferences.registerOnSharedPreferenceChangeListener(listener);
    }

    /**
     * 生成缓存文件夹
     */
    private void getCacheUrl() {
        if (CACHE_DIR != null) {
            return;
        }
        File sd = Environment.getExternalStorageDirectory();
        String path = sd.getPath() + "/TsuGunCache";
        File file = new File(path);
        if (!file.exists()) {
            file.mkdir();
        }
        CACHE_DIR = path + "/";
    }

    @Override
    protected void onStart() {
        super.onStart();
        onSettingChanged();
    }

    @Override
    protected void onResume() {
        super.onResume();
        checkPermission();
    }

    /**
     * 检测权限申请必要性
     */
    private void checkPermission() {
        if (isGranted) {
            onGranted();
            return;
        }
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            // 请求授予权限（读、写文件权限）
            grantedPermission(new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE});
        } else {
            onGranted();
        }
    }

    /**
     * 申请权限, 继承并添加执行程序
     */
    protected void grantedPermission(String[] permission) {
        // 判断是否已经被授权读取文件
        if (ContextCompat.checkSelfPermission(this,
                permission[0]) != PackageManager.PERMISSION_GRANTED) {
            // 未被授权，是否被拒绝过，判断并给出提示
            if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                    permission[0])) {
                Log.e(LogHelper.INSTANCE.getTAG(), "grantedPermission: 拒绝！！！");
            }
            // 申请授权,该方法是异步的，第二个参数可同时申请多个
            ActivityCompat.requestPermissions(this,
                    permission, PERMISSION_EXTERNAL_STORAGE);
        } else {
            onGranted();
        }
    }

    /**
     * 处理权限申请回调
     *
     * @param requestCode  申请代号
     * @param permissions  申请权限
     * @param grantResults 结果
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
                                           @NonNull int[] grantResults) {
        switch (requestCode) {
            case PERMISSION_EXTERNAL_STORAGE:
                // 如果申请被取消，结果数组为空，所以要进行判断结果数组是否为空
                if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                    // 权限被授予，做你需要做的
                    onGranted();
                } else {
                    // 权限未被授予
                    onNotGranted();
                }
        }
    }

    /**
     * 已授权
     */
    protected void onGranted() {
        getCacheUrl();
        isGranted = true;
        if (mMusicListProvider == null) {
            loadMusic();
        }
        if (isLoad) {
            onMusicLoadComplete(mMusicListProvider);
        }
    }

    /**
     * 未授权
     */
    protected void onNotGranted() {
        onMusicLoadFailed();
    }

    /**
     * 音乐加载失败
     */
    protected abstract void onMusicLoadFailed();

    /**
     * 音乐加载完成
     *
     * @param musicListProvider 音乐内容提供者
     */
    protected abstract void onMusicLoadComplete(ListProvider musicListProvider);

    /**
     * 设置修改回调
     */
    public abstract void onSettingChanged();

    @Override
    protected void onDestroy() {
        // 内存泄露分析工具
//        BaseApplication.getRefWatcher(this).watch(this);
        mSharedPreferences.unregisterOnSharedPreferenceChangeListener(listener);
        super.onDestroy();
    }

    /**
     * 释放内容提供者（建议在结束最底层的activity时调用）
     */
    protected void releaseProvider() {
        mMusicListProvider = null;
        isLoad = false;
        mFragmentManager = null;
    }

    /**
     * @return 获取内容
     */
    public ListProvider getListProvider() {
        if (mMusicListProvider == null) {
            return null;
        }
        return mMusicListProvider;
    }

//    /**
//     * 返回桌面
//     */
//    protected void returnHome() {
//        Intent intent = new Intent(Intent.ACTION_MAIN);
//        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
//        intent.addCategory(Intent.CATEGORY_HOME);
//        startActivity(intent);
//    }

    /**
     * @return 获取主页音乐界面管理
     */
    public MusicFragmentManager getMusicFragmentManager() {
        return mFragmentManager;
    }

    /**
     * 启动fragment
     *
     * @param fragment 需要启动的fragment
     */
    public void startFragment(Fragment fragment) {
        mFragmentManager.openFragment(fragment);
    }

    /**
     * 关闭所有fragment
     */
    protected void clearFragments() {
        for (int i = 0; i < mFragmentManager.getCount(); i++) {
            mFragmentManager.backFragment();
        }
    }

    /**
     * 获取主题颜色
     *
     * @return 颜色
     */
    public int getThemeColor() {
        return SettingPreferenceHelper.INSTANCE.getThemeColorPreference(this);
    }

    /**
     * 检测夜间模式
     */
    public void checkNightMode() {
        SettingPreferenceHelper.INSTANCE.setNightModeTheme(this);
    }

    /**
     * 获取Provider
     */
    public static ListProvider getMusicProvider() {
        if (mMusicListProvider != null) {
            return mMusicListProvider;
        }
        return null;
    }

    /**
     * 有 fragment
     * 在每次打开或者关闭时，如果存在 fragment 调用
     */
    public void hasFragment() {
    }

    /**
     * 在关闭 fragment 时，如果没有 fragment 则调用
     */
    public void noFragment() {
    }

    /**
     * 设置背景色
     * @param color 颜色
     */
    public void setBgColor(int color) {
    }

    /**
     * 设置修改回调
     */
    SharedPreferences.OnSharedPreferenceChangeListener listener =
            new SharedPreferences.OnSharedPreferenceChangeListener() {
                @Override
                public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
                    onSettingChanged();
                }
            };
}
